package com.sz.biz.common.utils;

import com.sz.biz.logistics.constants.OrderNumberConstants.RuleRegex;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

import static com.sz.biz.common.constants.SymbolConstants.*;

/**
 * Package: com.sz.biz.common.utils<br>
 * Description: 随机数字符串修正工具类
 * Author: WuHan<br>
 * Date: 2017-09-06 14:36<br>
 * @since sys-1.1.1.5
 * @version 1.0
 */
public class TrimString {
    /**
     * 使字符串中不出现连续的0及过多的0。
     * @param origin 原始字符串。
     * @return 去除多余0的字符串。
     * */
    public static String trimZero(String origin) {
        String temp = removeSeperator(origin);
        try {
            if (!temp.matches(RuleRegex.PURE_NUMBER)) {
                throw new IllegalArgumentException("非纯数字串！");
            }
            if (temp.substring(0,1).equals(SINGLE_ZERO)) {
            	temp = temp.replaceFirst(SINGLE_ZERO, SINGLE_FILLMENT);
            }
            while (temp.contains(SINGLE_ZERO + SINGLE_ZERO)
                    && temp.lastIndexOf(SINGLE_ZERO + SINGLE_ZERO) >= temp.length() / 2) {
                temp = temp.substring(0, temp.lastIndexOf(SINGLE_ZERO + SINGLE_ZERO))
                        + SINGLE_ZERO + SINGLE_FILLMENT
                        + temp.substring(temp.lastIndexOf(SINGLE_ZERO + SINGLE_ZERO) + 2);
            }
            while (countZero(temp) != 0
                    && countZero(temp) >= temp.length() / 3
                    && temp.lastIndexOf(SINGLE_ZERO) >= temp.length() / 2) {
                temp = temp.substring(0, temp.lastIndexOf(SINGLE_ZERO))
                        + "1"
                        + temp.substring(temp.lastIndexOf(SINGLE_ZERO) + 1);
            }
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        }
        return temp;
    }

    /**
     * 统计字符串中0的个数
     * @param origin 原始字符串。
     * @return 字符串中0的个数。
     * */
    public static int countZero(String origin) {
        int count = 0;
        for (int i = 0; i < origin.length(); i++) {
            if (origin.substring(i, i + 1).equals(SINGLE_ZERO)) {
                count++;
            }
        }
        return count;
    }

    /**
     * 去除字符串中常规的分隔符。
     * @param origin 原始字符串。
     * @return 修正后的字符串。
     * */
    private static String removeSeperator(String origin) {
        return origin.replaceAll(SEPERATOR_DOT, SEPERATOR_NULL)
                     .replaceAll(SEPERATOR_HYPHEN, SEPERATOR_NULL)
                     .replaceAll(SEPERATOR_SPACE, SEPERATOR_NULL)
                     .replaceAll(SEPERATOR_COMMA, SEPERATOR_NULL);
    }

    /**
     * 字符串数字升序重排
     * @param origin 待排序串
     * @return 各位升序排列的结果
     * */
    public static String ascRearrange(String origin) {
	    List<Integer> temp = new ArrayList<>();
	    for (char c : origin.toCharArray()) {
	    	temp.add(c - SINGLE_ZERO.charAt(0));
	    }
	    temp.sort((o1, o2) -> {
				    if (o1 < o2) {
					    return -1;
				    } else if (Objects.equals(o1, o2)) {
					    return 0;
				    } else {
					    return 1;
				    }
	    });
	    StringBuilder sbf = new StringBuilder();
	    for (Integer i : temp) {
	    	sbf.append(i);
	    }
	    return sbf.toString();
    }
    
    /**
     * 使用前置的"0"填充数字字符串至指定长度，以修正{@link Long#valueOf(String)}自带的抹零效果。
     * @param pattern 待填充串
     * @param length 要达到的长度
     * @return 串首填零的目的串
     * */
    public static String fillStringLengthByZero(String pattern, int length) {
        try {
            if (!pattern.matches(RuleRegex.PURE_NUMBER)) {
                throw new IllegalArgumentException("非纯数字串！");
            }
            if (pattern.length() > length) {
                throw new IllegalArgumentException("模式串长超出给定长度！");
            }
            StringBuilder patternBuilder = new StringBuilder(pattern);
            for (int i = 0; i < length - pattern.length(); i++) {
                patternBuilder.insert(0, SINGLE_ZERO);
            }
            pattern = patternBuilder.toString();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        }
        return pattern;
    }
}
